var pub = (function () {
    // 获取元素的样式
    function getStyle(ele, attr) {
        // ele: 元素
        // attr: 属性名
        if (window.getComputedStyle) { // 为真 标准
            return window.getComputedStyle(ele)[attr];
        } else {
            // ie
            return ele.currentStyle[attr];
        }
    }
    
    // 匀速移动
    // 1.1 提前声明变量用来存储定时器的唯一标识
    var timer = null;
    function move(ele, attr, step, target) {
        // ele: 元素
        // attr: 属性
        // step: 每一步移动的距离
        // target: 目标值
    
        // 判断当前位置 和 目标值的关系 0-->1000  +   1000-->0 -
        var start = parseInt(getStyle(ele, attr));
        step = start < target ? step : -step;
    
        clearInterval(timer);
        timer = setInterval(function () {
            var cur = parseInt(getStyle(ele, attr));
            var end = cur + step;
            if((end >= target && step > 0) || (end <= target && step < 0)){
                clearInterval(timer);
                end = target;
            }
            ele.style[attr] = end + 'px';
        }, 20);
    }
    
    // 求x-y之间的随机整数
    function getRandom(x, y) {
        return Math.floor(Math.random() * (y-x) + x);
    }
    
    
    // 补0的函数: <10 补0  >=0 用原数字
    function add0(n) {
        return n < 10 ? '0' + n : n;
    }
    
    
    // 生成随机验证码
    function getRandomCode(len, array) {
        // 可选项
        len = len ? len : 4;    
        array = array ? array : '0123456789';
        // 生成6位随机下标
        var s = '';
        for (var i = 0; i < len; i++) {
            var n = Math.floor(Math.random() * array.length);
            s += array[n];
        }
        return s;
    }
    
    // 綁定事件
    function bind(ele, type, fn) {
        if (ele.addEventListener) {
            ele.addEventListener(type, fn);
        } else {
            ele.attachEvent('on' + type, fn);
        }
    }
    
    // 解除绑定事件
    function unbind(ele, type, fn) {
        if (ele.removeEventListener) {
            ele.removeEventListener(type, fn);
        } else {
            ele.detachEvent('on' + type, fn);
        }
    }
    
    // 缓冲运动
    function buffMove(ele, json, fn) {
        clearInterval(ele.t);
        ele.t = setInterval(function () {
            var tag = true;
    
            for (var key in json) {
                if (key == 'opacity') {
                    var cur = parseInt(getStyle(ele, key) * 100);
                } else {
                    var cur = parseInt(getStyle(ele, key));
                }
                var speed = (json[key] - cur) / 20;
    
                speed = speed > 0 ? Math.ceil(speed) : Math.floor(speed);
    
                var end = cur + speed;
                if (end != json[key]) {
                    tag = false;
                }
    
                if (key == 'opacity') {
                    ele.style[key] = end / 100;
                } else {
                    ele.style[key] = end + 'px';
                }
            }
            if (tag) {
                clearInterval(ele.t);
                fn && fn();
            }
        }, 20);
    };
    
    // 拖拽元素
    function drag(ele){
        // ele: 元素
        ele.onmousedown = function (evs) {
            var ev = window.event || evs;
            var x1 = ev.clientX - ele.offsetLeft;
            var y1 = ev.clientY - ele.offsetTop;
            document.onmousemove = function (evs){
                var ev = window.event || evs;
                var l = ev.clientX - x1;
                var t = ev.clientY - y1;
                ele.style.left = l + 'px';
                ele.style.top = t + 'px';
            }
    
            if(ele.setCapture){
               ele.setCapture();
            }
            return false;
        };
        document.onmouseup = function () {
            document.onmousemove = null;
            if(ele.releaseCapture){
                ele.releaseCapture();
            }
        };
    
    }

    // 快速排序的函数 quicksort
    function qs(arr) {
        // 如果数组的长度比1小 不需要
        if(arr.length <= 1){
            return arr;
        }

        // 开始排序: 找到中间下标
        var ind = Math.floor(arr.length / 2); // 3/2=1.5  0 1 2

        // 找到中间值
        var val = arr[ind];

        // 删除中间值
        arr.splice(ind, 1);

        // 创建两个空数组
        var l = [], r = [];

        // 将arr中的数据分类
        for(var i = 0; i < arr.length; i++){
            if(arr[i] < val){
                l.push(arr[i]);
            } else {
                r.push(arr[i]);
            }
        }
        return qs(l).concat(val, qs(r));
    }

    // 防抖函数
    function debounce(t, fn) {
        // t: 时间 ms
        // fn: 函数
        var timer = null;

        // 内部函数
        function inner() {
            clearTimeout(timer);
            timer = setTimeout(fn, t);
        }

        // 设置返回值
        return inner;
    }

    // 节流
    function throttle(t, fn) {
        var timer = null; // 唯一标识

        // 主体代码
        function inner() {
            if(!timer){ // !false -- true  !null --> true
                timer = setTimeout(function () { // timer = 1
                    fn();
                    // 状态变成可用状态
                    timer = null;
                }, t);
            }
        }
        return inner;
    }


    // 设置返回值
    return {
        getStyle: getStyle,
        move: move,
        getRandom: getRandom,
        add0: add0,
        getRandomCode: getRandomCode,
        bind: bind,
        unbind: unbind,
        buffMove: buffMove,
        drag: drag,
        qs: qs,
        debounce: debounce,
        throttle: throttle
    };

})();

// console.log(pub);